// 蜂窝蜜造平台生成代码，如手工更改，请添加到 .beeignore 忽略生成

package com.fowo.api.model.tmp.settlement.report;

import com.fowo.api.common.annotaion.DataObjectType;
import com.fowo.api.common.meta.MetaDataObject;
import com.fowo.api.common.meta.MetaDataObjects;
import com.fowo.api.common.model.PageSearch;
import com.fowo.api.common.mybatis.helper.PageSearchHelper;
import com.fowo.api.common.util.ListUtils;
import com.fowo.api.entity.TmpSettlementReport;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import lombok.Getter;
import lombok.Setter;
import org.springframework.format.annotation.DateTimeFormat;

@DataObjectType(TmpSettlementReport.class)
@Setter
@Getter
public class TmpSettlementReportSearchParamPo extends PageSearch {

  private static MetaDataObject metaDataObject;

  @Override
  public void applySqlSegments() {
    if (metaDataObject == null) {
      metaDataObject =
        ListUtils.find(
          MetaDataObjects.getObjects(),
          o -> "TmpSettlementReport".equals(o.getName())
        );
    }
    PageSearchHelper.fillSqlSegments(this, metaDataObject);
  }

  @Override
  public void initFinal() {
    super.initFinal();
    applySqlSegments();
  }

  /**
   * 获取关联字段的查询表别名信息
   */
  @Override
  public Map<String, String> getJoinFieldTableAliasMap() {
    Map<String, String> map = new HashMap<>();
    return map;
  }

  @Override
  public Map<String, OptionalJoinField> getOptionalJoinFields() {
    Map<String, OptionalJoinField> map = new HashMap<>();

    return map;
  }

  /**
   * 编号
   */
  private Long id;

  /**
   * 最小编号
   */
  private Long idMin;

  /**
   * 最大编号
   */
  private Long idMax;

  /**
   * 编号 比较(eq)
   */
  private Long idEq;
  /**
   * 编号 比较(neq)
   */
  private Long idNeq;
  /**
   * 编号 比较(gt)
   */
  private Long idGt;
  /**
   * 编号 比较(gte)
   */
  private Long idGte;
  /**
   * 编号 比较(lt)
   */
  private Long idLt;
  /**
   * 编号 比较(lte)
   */
  private Long idLte;
  /**
   * 编号 比较(contains)
   */
  private Long idContains;
  /**
   * 编号 比较(notcontains)
   */
  private Long idNotcontains;
  /**
   * 编号 比较(startswith)
   */
  private Long idStartswith;
  /**
   * 编号 比较(endswith)
   */
  private Long idEndswith;
  /**
   * 编号 比较(isnull)
   */
  private Boolean idIsnull;
  /**
   * 编号 比较(isnotnull)
   */
  private Boolean idIsnotnull;

  /**
   * 最早创建时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date createTimeStart;

  /**
   * 最晚创建时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date createTimeEnd;

  /**
   * 创建时间 比较(eq)
   */
  private Date createTimeEq;
  /**
   * 创建时间 比较(neq)
   */
  private Date createTimeNeq;
  /**
   * 创建时间 比较(gt)
   */
  private Date createTimeGt;
  /**
   * 创建时间 比较(gte)
   */
  private Date createTimeGte;
  /**
   * 创建时间 比较(lt)
   */
  private Date createTimeLt;
  /**
   * 创建时间 比较(lte)
   */
  private Date createTimeLte;
  /**
   * 创建时间 比较(contains)
   */
  private Date createTimeContains;
  /**
   * 创建时间 比较(notcontains)
   */
  private Date createTimeNotcontains;
  /**
   * 创建时间 比较(startswith)
   */
  private Date createTimeStartswith;
  /**
   * 创建时间 比较(endswith)
   */
  private Date createTimeEndswith;
  /**
   * 创建时间 比较(isnull)
   */
  private Boolean createTimeIsnull;
  /**
   * 创建时间 比较(isnotnull)
   */
  private Boolean createTimeIsnotnull;

  /**
   * 创建人
   */
  private Long createUser;

  /**
   * 最小创建人
   */
  private Long createUserMin;

  /**
   * 最大创建人
   */
  private Long createUserMax;

  /**
   * 创建人 比较(eq)
   */
  private Long createUserEq;
  /**
   * 创建人 比较(neq)
   */
  private Long createUserNeq;
  /**
   * 创建人 比较(gt)
   */
  private Long createUserGt;
  /**
   * 创建人 比较(gte)
   */
  private Long createUserGte;
  /**
   * 创建人 比较(lt)
   */
  private Long createUserLt;
  /**
   * 创建人 比较(lte)
   */
  private Long createUserLte;
  /**
   * 创建人 比较(contains)
   */
  private Long createUserContains;
  /**
   * 创建人 比较(notcontains)
   */
  private Long createUserNotcontains;
  /**
   * 创建人 比较(startswith)
   */
  private Long createUserStartswith;
  /**
   * 创建人 比较(endswith)
   */
  private Long createUserEndswith;
  /**
   * 创建人 比较(isnull)
   */
  private Boolean createUserIsnull;
  /**
   * 创建人 比较(isnotnull)
   */
  private Boolean createUserIsnotnull;

  /**
   * 最早更新时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date lastUpdateTimeStart;

  /**
   * 最晚更新时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date lastUpdateTimeEnd;

  /**
   * 更新时间 比较(eq)
   */
  private Date lastUpdateTimeEq;
  /**
   * 更新时间 比较(neq)
   */
  private Date lastUpdateTimeNeq;
  /**
   * 更新时间 比较(gt)
   */
  private Date lastUpdateTimeGt;
  /**
   * 更新时间 比较(gte)
   */
  private Date lastUpdateTimeGte;
  /**
   * 更新时间 比较(lt)
   */
  private Date lastUpdateTimeLt;
  /**
   * 更新时间 比较(lte)
   */
  private Date lastUpdateTimeLte;
  /**
   * 更新时间 比较(contains)
   */
  private Date lastUpdateTimeContains;
  /**
   * 更新时间 比较(notcontains)
   */
  private Date lastUpdateTimeNotcontains;
  /**
   * 更新时间 比较(startswith)
   */
  private Date lastUpdateTimeStartswith;
  /**
   * 更新时间 比较(endswith)
   */
  private Date lastUpdateTimeEndswith;
  /**
   * 更新时间 比较(isnull)
   */
  private Boolean lastUpdateTimeIsnull;
  /**
   * 更新时间 比较(isnotnull)
   */
  private Boolean lastUpdateTimeIsnotnull;

  /**
   * 更新人
   */
  private Long lastUpdateUser;

  /**
   * 最小更新人
   */
  private Long lastUpdateUserMin;

  /**
   * 最大更新人
   */
  private Long lastUpdateUserMax;

  /**
   * 更新人 比较(eq)
   */
  private Long lastUpdateUserEq;
  /**
   * 更新人 比较(neq)
   */
  private Long lastUpdateUserNeq;
  /**
   * 更新人 比较(gt)
   */
  private Long lastUpdateUserGt;
  /**
   * 更新人 比较(gte)
   */
  private Long lastUpdateUserGte;
  /**
   * 更新人 比较(lt)
   */
  private Long lastUpdateUserLt;
  /**
   * 更新人 比较(lte)
   */
  private Long lastUpdateUserLte;
  /**
   * 更新人 比较(contains)
   */
  private Long lastUpdateUserContains;
  /**
   * 更新人 比较(notcontains)
   */
  private Long lastUpdateUserNotcontains;
  /**
   * 更新人 比较(startswith)
   */
  private Long lastUpdateUserStartswith;
  /**
   * 更新人 比较(endswith)
   */
  private Long lastUpdateUserEndswith;
  /**
   * 更新人 比较(isnull)
   */
  private Boolean lastUpdateUserIsnull;
  /**
   * 更新人 比较(isnotnull)
   */
  private Boolean lastUpdateUserIsnotnull;

  /**
   * Settlement ID(模糊搜索)
   */
  private String settlementId;

  /**
   * Settlement ID 比较(eq)
   */
  private String settlementIdEq;
  /**
   * Settlement ID 比较(neq)
   */
  private String settlementIdNeq;
  /**
   * Settlement ID 比较(gt)
   */
  private String settlementIdGt;
  /**
   * Settlement ID 比较(gte)
   */
  private String settlementIdGte;
  /**
   * Settlement ID 比较(lt)
   */
  private String settlementIdLt;
  /**
   * Settlement ID 比较(lte)
   */
  private String settlementIdLte;
  /**
   * Settlement ID 比较(contains)
   */
  private String settlementIdContains;
  /**
   * Settlement ID 比较(notcontains)
   */
  private String settlementIdNotcontains;
  /**
   * Settlement ID 比较(startswith)
   */
  private String settlementIdStartswith;
  /**
   * Settlement ID 比较(endswith)
   */
  private String settlementIdEndswith;
  /**
   * Settlement ID 比较(isnull)
   */
  private Boolean settlementIdIsnull;
  /**
   * Settlement ID 比较(isnotnull)
   */
  private Boolean settlementIdIsnotnull;

  /**
   * Settlement ID(精确搜索)
   */
  private List<String> settlementIdInList;

  /**
   * 最早结算开始日期
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date settlementStartDateStart;

  /**
   * 最晚结算开始日期
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date settlementStartDateEnd;

  /**
   * 结算开始日期 比较(eq)
   */
  private Date settlementStartDateEq;
  /**
   * 结算开始日期 比较(neq)
   */
  private Date settlementStartDateNeq;
  /**
   * 结算开始日期 比较(gt)
   */
  private Date settlementStartDateGt;
  /**
   * 结算开始日期 比较(gte)
   */
  private Date settlementStartDateGte;
  /**
   * 结算开始日期 比较(lt)
   */
  private Date settlementStartDateLt;
  /**
   * 结算开始日期 比较(lte)
   */
  private Date settlementStartDateLte;
  /**
   * 结算开始日期 比较(contains)
   */
  private Date settlementStartDateContains;
  /**
   * 结算开始日期 比较(notcontains)
   */
  private Date settlementStartDateNotcontains;
  /**
   * 结算开始日期 比较(startswith)
   */
  private Date settlementStartDateStartswith;
  /**
   * 结算开始日期 比较(endswith)
   */
  private Date settlementStartDateEndswith;
  /**
   * 结算开始日期 比较(isnull)
   */
  private Boolean settlementStartDateIsnull;
  /**
   * 结算开始日期 比较(isnotnull)
   */
  private Boolean settlementStartDateIsnotnull;

  /**
   * 最早结算结束日期
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date settlementEndDateStart;

  /**
   * 最晚结算结束日期
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date settlementEndDateEnd;

  /**
   * 结算结束日期 比较(eq)
   */
  private Date settlementEndDateEq;
  /**
   * 结算结束日期 比较(neq)
   */
  private Date settlementEndDateNeq;
  /**
   * 结算结束日期 比较(gt)
   */
  private Date settlementEndDateGt;
  /**
   * 结算结束日期 比较(gte)
   */
  private Date settlementEndDateGte;
  /**
   * 结算结束日期 比较(lt)
   */
  private Date settlementEndDateLt;
  /**
   * 结算结束日期 比较(lte)
   */
  private Date settlementEndDateLte;
  /**
   * 结算结束日期 比较(contains)
   */
  private Date settlementEndDateContains;
  /**
   * 结算结束日期 比较(notcontains)
   */
  private Date settlementEndDateNotcontains;
  /**
   * 结算结束日期 比较(startswith)
   */
  private Date settlementEndDateStartswith;
  /**
   * 结算结束日期 比较(endswith)
   */
  private Date settlementEndDateEndswith;
  /**
   * 结算结束日期 比较(isnull)
   */
  private Boolean settlementEndDateIsnull;
  /**
   * 结算结束日期 比较(isnotnull)
   */
  private Boolean settlementEndDateIsnotnull;

  /**
   * 最早存款日期
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date depositDateStart;

  /**
   * 最晚存款日期
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date depositDateEnd;

  /**
   * 存款日期 比较(eq)
   */
  private Date depositDateEq;
  /**
   * 存款日期 比较(neq)
   */
  private Date depositDateNeq;
  /**
   * 存款日期 比较(gt)
   */
  private Date depositDateGt;
  /**
   * 存款日期 比较(gte)
   */
  private Date depositDateGte;
  /**
   * 存款日期 比较(lt)
   */
  private Date depositDateLt;
  /**
   * 存款日期 比较(lte)
   */
  private Date depositDateLte;
  /**
   * 存款日期 比较(contains)
   */
  private Date depositDateContains;
  /**
   * 存款日期 比较(notcontains)
   */
  private Date depositDateNotcontains;
  /**
   * 存款日期 比较(startswith)
   */
  private Date depositDateStartswith;
  /**
   * 存款日期 比较(endswith)
   */
  private Date depositDateEndswith;
  /**
   * 存款日期 比较(isnull)
   */
  private Boolean depositDateIsnull;
  /**
   * 存款日期 比较(isnotnull)
   */
  private Boolean depositDateIsnotnull;

  /**
   * 货币(模糊搜索)
   */
  private String currency;

  /**
   * 货币 比较(eq)
   */
  private String currencyEq;
  /**
   * 货币 比较(neq)
   */
  private String currencyNeq;
  /**
   * 货币 比较(gt)
   */
  private String currencyGt;
  /**
   * 货币 比较(gte)
   */
  private String currencyGte;
  /**
   * 货币 比较(lt)
   */
  private String currencyLt;
  /**
   * 货币 比较(lte)
   */
  private String currencyLte;
  /**
   * 货币 比较(contains)
   */
  private String currencyContains;
  /**
   * 货币 比较(notcontains)
   */
  private String currencyNotcontains;
  /**
   * 货币 比较(startswith)
   */
  private String currencyStartswith;
  /**
   * 货币 比较(endswith)
   */
  private String currencyEndswith;
  /**
   * 货币 比较(isnull)
   */
  private Boolean currencyIsnull;
  /**
   * 货币 比较(isnotnull)
   */
  private Boolean currencyIsnotnull;

  /**
   * 货币(精确搜索)
   */
  private List<String> currencyInList;

  /**
   * 交易类型(模糊搜索)
   */
  private String transactionType;

  /**
   * 交易类型 比较(eq)
   */
  private String transactionTypeEq;
  /**
   * 交易类型 比较(neq)
   */
  private String transactionTypeNeq;
  /**
   * 交易类型 比较(gt)
   */
  private String transactionTypeGt;
  /**
   * 交易类型 比较(gte)
   */
  private String transactionTypeGte;
  /**
   * 交易类型 比较(lt)
   */
  private String transactionTypeLt;
  /**
   * 交易类型 比较(lte)
   */
  private String transactionTypeLte;
  /**
   * 交易类型 比较(contains)
   */
  private String transactionTypeContains;
  /**
   * 交易类型 比较(notcontains)
   */
  private String transactionTypeNotcontains;
  /**
   * 交易类型 比较(startswith)
   */
  private String transactionTypeStartswith;
  /**
   * 交易类型 比较(endswith)
   */
  private String transactionTypeEndswith;
  /**
   * 交易类型 比较(isnull)
   */
  private Boolean transactionTypeIsnull;
  /**
   * 交易类型 比较(isnotnull)
   */
  private Boolean transactionTypeIsnotnull;

  /**
   * 交易类型(精确搜索)
   */
  private List<String> transactionTypeInList;

  /**
   * 订单编号(模糊搜索)
   */
  private String orderId;

  /**
   * 订单编号 比较(eq)
   */
  private String orderIdEq;
  /**
   * 订单编号 比较(neq)
   */
  private String orderIdNeq;
  /**
   * 订单编号 比较(gt)
   */
  private String orderIdGt;
  /**
   * 订单编号 比较(gte)
   */
  private String orderIdGte;
  /**
   * 订单编号 比较(lt)
   */
  private String orderIdLt;
  /**
   * 订单编号 比较(lte)
   */
  private String orderIdLte;
  /**
   * 订单编号 比较(contains)
   */
  private String orderIdContains;
  /**
   * 订单编号 比较(notcontains)
   */
  private String orderIdNotcontains;
  /**
   * 订单编号 比较(startswith)
   */
  private String orderIdStartswith;
  /**
   * 订单编号 比较(endswith)
   */
  private String orderIdEndswith;
  /**
   * 订单编号 比较(isnull)
   */
  private Boolean orderIdIsnull;
  /**
   * 订单编号 比较(isnotnull)
   */
  private Boolean orderIdIsnotnull;

  /**
   * 订单编号(精确搜索)
   */
  private List<String> orderIdInList;

  /**
   * 卖家订单编号(模糊搜索)
   */
  private String merchantOrderId;

  /**
   * 卖家订单编号 比较(eq)
   */
  private String merchantOrderIdEq;
  /**
   * 卖家订单编号 比较(neq)
   */
  private String merchantOrderIdNeq;
  /**
   * 卖家订单编号 比较(gt)
   */
  private String merchantOrderIdGt;
  /**
   * 卖家订单编号 比较(gte)
   */
  private String merchantOrderIdGte;
  /**
   * 卖家订单编号 比较(lt)
   */
  private String merchantOrderIdLt;
  /**
   * 卖家订单编号 比较(lte)
   */
  private String merchantOrderIdLte;
  /**
   * 卖家订单编号 比较(contains)
   */
  private String merchantOrderIdContains;
  /**
   * 卖家订单编号 比较(notcontains)
   */
  private String merchantOrderIdNotcontains;
  /**
   * 卖家订单编号 比较(startswith)
   */
  private String merchantOrderIdStartswith;
  /**
   * 卖家订单编号 比较(endswith)
   */
  private String merchantOrderIdEndswith;
  /**
   * 卖家订单编号 比较(isnull)
   */
  private Boolean merchantOrderIdIsnull;
  /**
   * 卖家订单编号 比较(isnotnull)
   */
  private Boolean merchantOrderIdIsnotnull;

  /**
   * 卖家订单编号(精确搜索)
   */
  private List<String> merchantOrderIdInList;

  /**
   * 盘点编号(模糊搜索)
   */
  private String adjustmentId;

  /**
   * 盘点编号 比较(eq)
   */
  private String adjustmentIdEq;
  /**
   * 盘点编号 比较(neq)
   */
  private String adjustmentIdNeq;
  /**
   * 盘点编号 比较(gt)
   */
  private String adjustmentIdGt;
  /**
   * 盘点编号 比较(gte)
   */
  private String adjustmentIdGte;
  /**
   * 盘点编号 比较(lt)
   */
  private String adjustmentIdLt;
  /**
   * 盘点编号 比较(lte)
   */
  private String adjustmentIdLte;
  /**
   * 盘点编号 比较(contains)
   */
  private String adjustmentIdContains;
  /**
   * 盘点编号 比较(notcontains)
   */
  private String adjustmentIdNotcontains;
  /**
   * 盘点编号 比较(startswith)
   */
  private String adjustmentIdStartswith;
  /**
   * 盘点编号 比较(endswith)
   */
  private String adjustmentIdEndswith;
  /**
   * 盘点编号 比较(isnull)
   */
  private Boolean adjustmentIdIsnull;
  /**
   * 盘点编号 比较(isnotnull)
   */
  private Boolean adjustmentIdIsnotnull;

  /**
   * 盘点编号(精确搜索)
   */
  private List<String> adjustmentIdInList;

  /**
   * 货件编号(模糊搜索)
   */
  private String shipmentId;

  /**
   * 货件编号 比较(eq)
   */
  private String shipmentIdEq;
  /**
   * 货件编号 比较(neq)
   */
  private String shipmentIdNeq;
  /**
   * 货件编号 比较(gt)
   */
  private String shipmentIdGt;
  /**
   * 货件编号 比较(gte)
   */
  private String shipmentIdGte;
  /**
   * 货件编号 比较(lt)
   */
  private String shipmentIdLt;
  /**
   * 货件编号 比较(lte)
   */
  private String shipmentIdLte;
  /**
   * 货件编号 比较(contains)
   */
  private String shipmentIdContains;
  /**
   * 货件编号 比较(notcontains)
   */
  private String shipmentIdNotcontains;
  /**
   * 货件编号 比较(startswith)
   */
  private String shipmentIdStartswith;
  /**
   * 货件编号 比较(endswith)
   */
  private String shipmentIdEndswith;
  /**
   * 货件编号 比较(isnull)
   */
  private Boolean shipmentIdIsnull;
  /**
   * 货件编号 比较(isnotnull)
   */
  private Boolean shipmentIdIsnotnull;

  /**
   * 货件编号(精确搜索)
   */
  private List<String> shipmentIdInList;

  /**
   * 商城名称(模糊搜索)
   */
  private String marketplaceName;

  /**
   * 商城名称 比较(eq)
   */
  private String marketplaceNameEq;
  /**
   * 商城名称 比较(neq)
   */
  private String marketplaceNameNeq;
  /**
   * 商城名称 比较(gt)
   */
  private String marketplaceNameGt;
  /**
   * 商城名称 比较(gte)
   */
  private String marketplaceNameGte;
  /**
   * 商城名称 比较(lt)
   */
  private String marketplaceNameLt;
  /**
   * 商城名称 比较(lte)
   */
  private String marketplaceNameLte;
  /**
   * 商城名称 比较(contains)
   */
  private String marketplaceNameContains;
  /**
   * 商城名称 比较(notcontains)
   */
  private String marketplaceNameNotcontains;
  /**
   * 商城名称 比较(startswith)
   */
  private String marketplaceNameStartswith;
  /**
   * 商城名称 比较(endswith)
   */
  private String marketplaceNameEndswith;
  /**
   * 商城名称 比较(isnull)
   */
  private Boolean marketplaceNameIsnull;
  /**
   * 商城名称 比较(isnotnull)
   */
  private Boolean marketplaceNameIsnotnull;

  /**
   * 商城名称(精确搜索)
   */
  private List<String> marketplaceNameInList;

  /**
   * 金额类型(模糊搜索)
   */
  private String amountType;

  /**
   * 金额类型 比较(eq)
   */
  private String amountTypeEq;
  /**
   * 金额类型 比较(neq)
   */
  private String amountTypeNeq;
  /**
   * 金额类型 比较(gt)
   */
  private String amountTypeGt;
  /**
   * 金额类型 比较(gte)
   */
  private String amountTypeGte;
  /**
   * 金额类型 比较(lt)
   */
  private String amountTypeLt;
  /**
   * 金额类型 比较(lte)
   */
  private String amountTypeLte;
  /**
   * 金额类型 比较(contains)
   */
  private String amountTypeContains;
  /**
   * 金额类型 比较(notcontains)
   */
  private String amountTypeNotcontains;
  /**
   * 金额类型 比较(startswith)
   */
  private String amountTypeStartswith;
  /**
   * 金额类型 比较(endswith)
   */
  private String amountTypeEndswith;
  /**
   * 金额类型 比较(isnull)
   */
  private Boolean amountTypeIsnull;
  /**
   * 金额类型 比较(isnotnull)
   */
  private Boolean amountTypeIsnotnull;

  /**
   * 金额类型(精确搜索)
   */
  private List<String> amountTypeInList;

  /**
   * 金额描述(模糊搜索)
   */
  private String amountDescription;

  /**
   * 金额描述 比较(eq)
   */
  private String amountDescriptionEq;
  /**
   * 金额描述 比较(neq)
   */
  private String amountDescriptionNeq;
  /**
   * 金额描述 比较(gt)
   */
  private String amountDescriptionGt;
  /**
   * 金额描述 比较(gte)
   */
  private String amountDescriptionGte;
  /**
   * 金额描述 比较(lt)
   */
  private String amountDescriptionLt;
  /**
   * 金额描述 比较(lte)
   */
  private String amountDescriptionLte;
  /**
   * 金额描述 比较(contains)
   */
  private String amountDescriptionContains;
  /**
   * 金额描述 比较(notcontains)
   */
  private String amountDescriptionNotcontains;
  /**
   * 金额描述 比较(startswith)
   */
  private String amountDescriptionStartswith;
  /**
   * 金额描述 比较(endswith)
   */
  private String amountDescriptionEndswith;
  /**
   * 金额描述 比较(isnull)
   */
  private Boolean amountDescriptionIsnull;
  /**
   * 金额描述 比较(isnotnull)
   */
  private Boolean amountDescriptionIsnotnull;

  /**
   * 金额描述(精确搜索)
   */
  private List<String> amountDescriptionInList;

  /**
   * 金额
   */
  private java.math.BigDecimal amount;

  /**
   * 最小金额
   */
  private java.math.BigDecimal amountMin;

  /**
   * 最大金额
   */
  private java.math.BigDecimal amountMax;

  /**
   * 金额 比较(eq)
   */
  private java.math.BigDecimal amountEq;
  /**
   * 金额 比较(neq)
   */
  private java.math.BigDecimal amountNeq;
  /**
   * 金额 比较(gt)
   */
  private java.math.BigDecimal amountGt;
  /**
   * 金额 比较(gte)
   */
  private java.math.BigDecimal amountGte;
  /**
   * 金额 比较(lt)
   */
  private java.math.BigDecimal amountLt;
  /**
   * 金额 比较(lte)
   */
  private java.math.BigDecimal amountLte;
  /**
   * 金额 比较(contains)
   */
  private java.math.BigDecimal amountContains;
  /**
   * 金额 比较(notcontains)
   */
  private java.math.BigDecimal amountNotcontains;
  /**
   * 金额 比较(startswith)
   */
  private java.math.BigDecimal amountStartswith;
  /**
   * 金额 比较(endswith)
   */
  private java.math.BigDecimal amountEndswith;
  /**
   * 金额 比较(isnull)
   */
  private Boolean amountIsnull;
  /**
   * 金额 比较(isnotnull)
   */
  private Boolean amountIsnotnull;

  /**
   * 配送类型(模糊搜索)
   */
  private String fulfillmentId;

  /**
   * 配送类型 比较(eq)
   */
  private String fulfillmentIdEq;
  /**
   * 配送类型 比较(neq)
   */
  private String fulfillmentIdNeq;
  /**
   * 配送类型 比较(gt)
   */
  private String fulfillmentIdGt;
  /**
   * 配送类型 比较(gte)
   */
  private String fulfillmentIdGte;
  /**
   * 配送类型 比较(lt)
   */
  private String fulfillmentIdLt;
  /**
   * 配送类型 比较(lte)
   */
  private String fulfillmentIdLte;
  /**
   * 配送类型 比较(contains)
   */
  private String fulfillmentIdContains;
  /**
   * 配送类型 比较(notcontains)
   */
  private String fulfillmentIdNotcontains;
  /**
   * 配送类型 比较(startswith)
   */
  private String fulfillmentIdStartswith;
  /**
   * 配送类型 比较(endswith)
   */
  private String fulfillmentIdEndswith;
  /**
   * 配送类型 比较(isnull)
   */
  private Boolean fulfillmentIdIsnull;
  /**
   * 配送类型 比较(isnotnull)
   */
  private Boolean fulfillmentIdIsnotnull;

  /**
   * 配送类型(精确搜索)
   */
  private List<String> fulfillmentIdInList;

  /**
   * 最早发布日期
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date postedDateStart;

  /**
   * 最晚发布日期
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date postedDateEnd;

  /**
   * 发布日期 比较(eq)
   */
  private Date postedDateEq;
  /**
   * 发布日期 比较(neq)
   */
  private Date postedDateNeq;
  /**
   * 发布日期 比较(gt)
   */
  private Date postedDateGt;
  /**
   * 发布日期 比较(gte)
   */
  private Date postedDateGte;
  /**
   * 发布日期 比较(lt)
   */
  private Date postedDateLt;
  /**
   * 发布日期 比较(lte)
   */
  private Date postedDateLte;
  /**
   * 发布日期 比较(contains)
   */
  private Date postedDateContains;
  /**
   * 发布日期 比较(notcontains)
   */
  private Date postedDateNotcontains;
  /**
   * 发布日期 比较(startswith)
   */
  private Date postedDateStartswith;
  /**
   * 发布日期 比较(endswith)
   */
  private Date postedDateEndswith;
  /**
   * 发布日期 比较(isnull)
   */
  private Boolean postedDateIsnull;
  /**
   * 发布日期 比较(isnotnull)
   */
  private Boolean postedDateIsnotnull;

  /**
   * 最早发布日期时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date postedDateTimeStart;

  /**
   * 最晚发布日期时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date postedDateTimeEnd;

  /**
   * 发布日期时间 比较(eq)
   */
  private Date postedDateTimeEq;
  /**
   * 发布日期时间 比较(neq)
   */
  private Date postedDateTimeNeq;
  /**
   * 发布日期时间 比较(gt)
   */
  private Date postedDateTimeGt;
  /**
   * 发布日期时间 比较(gte)
   */
  private Date postedDateTimeGte;
  /**
   * 发布日期时间 比较(lt)
   */
  private Date postedDateTimeLt;
  /**
   * 发布日期时间 比较(lte)
   */
  private Date postedDateTimeLte;
  /**
   * 发布日期时间 比较(contains)
   */
  private Date postedDateTimeContains;
  /**
   * 发布日期时间 比较(notcontains)
   */
  private Date postedDateTimeNotcontains;
  /**
   * 发布日期时间 比较(startswith)
   */
  private Date postedDateTimeStartswith;
  /**
   * 发布日期时间 比较(endswith)
   */
  private Date postedDateTimeEndswith;
  /**
   * 发布日期时间 比较(isnull)
   */
  private Boolean postedDateTimeIsnull;
  /**
   * 发布日期时间 比较(isnotnull)
   */
  private Boolean postedDateTimeIsnotnull;

  /**
   * 订单商品编号(模糊搜索)
   */
  private String orderItemCode;

  /**
   * 订单商品编号 比较(eq)
   */
  private String orderItemCodeEq;
  /**
   * 订单商品编号 比较(neq)
   */
  private String orderItemCodeNeq;
  /**
   * 订单商品编号 比较(gt)
   */
  private String orderItemCodeGt;
  /**
   * 订单商品编号 比较(gte)
   */
  private String orderItemCodeGte;
  /**
   * 订单商品编号 比较(lt)
   */
  private String orderItemCodeLt;
  /**
   * 订单商品编号 比较(lte)
   */
  private String orderItemCodeLte;
  /**
   * 订单商品编号 比较(contains)
   */
  private String orderItemCodeContains;
  /**
   * 订单商品编号 比较(notcontains)
   */
  private String orderItemCodeNotcontains;
  /**
   * 订单商品编号 比较(startswith)
   */
  private String orderItemCodeStartswith;
  /**
   * 订单商品编号 比较(endswith)
   */
  private String orderItemCodeEndswith;
  /**
   * 订单商品编号 比较(isnull)
   */
  private Boolean orderItemCodeIsnull;
  /**
   * 订单商品编号 比较(isnotnull)
   */
  private Boolean orderItemCodeIsnotnull;

  /**
   * 订单商品编号(精确搜索)
   */
  private List<String> orderItemCodeInList;

  /**
   * 卖家订单商品编号(模糊搜索)
   */
  private String merchantOrderItemId;

  /**
   * 卖家订单商品编号 比较(eq)
   */
  private String merchantOrderItemIdEq;
  /**
   * 卖家订单商品编号 比较(neq)
   */
  private String merchantOrderItemIdNeq;
  /**
   * 卖家订单商品编号 比较(gt)
   */
  private String merchantOrderItemIdGt;
  /**
   * 卖家订单商品编号 比较(gte)
   */
  private String merchantOrderItemIdGte;
  /**
   * 卖家订单商品编号 比较(lt)
   */
  private String merchantOrderItemIdLt;
  /**
   * 卖家订单商品编号 比较(lte)
   */
  private String merchantOrderItemIdLte;
  /**
   * 卖家订单商品编号 比较(contains)
   */
  private String merchantOrderItemIdContains;
  /**
   * 卖家订单商品编号 比较(notcontains)
   */
  private String merchantOrderItemIdNotcontains;
  /**
   * 卖家订单商品编号 比较(startswith)
   */
  private String merchantOrderItemIdStartswith;
  /**
   * 卖家订单商品编号 比较(endswith)
   */
  private String merchantOrderItemIdEndswith;
  /**
   * 卖家订单商品编号 比较(isnull)
   */
  private Boolean merchantOrderItemIdIsnull;
  /**
   * 卖家订单商品编号 比较(isnotnull)
   */
  private Boolean merchantOrderItemIdIsnotnull;

  /**
   * 卖家订单商品编号(精确搜索)
   */
  private List<String> merchantOrderItemIdInList;

  /**
   * 卖家盘点商品编号(模糊搜索)
   */
  private String merchantAdjustmentItemId;

  /**
   * 卖家盘点商品编号 比较(eq)
   */
  private String merchantAdjustmentItemIdEq;
  /**
   * 卖家盘点商品编号 比较(neq)
   */
  private String merchantAdjustmentItemIdNeq;
  /**
   * 卖家盘点商品编号 比较(gt)
   */
  private String merchantAdjustmentItemIdGt;
  /**
   * 卖家盘点商品编号 比较(gte)
   */
  private String merchantAdjustmentItemIdGte;
  /**
   * 卖家盘点商品编号 比较(lt)
   */
  private String merchantAdjustmentItemIdLt;
  /**
   * 卖家盘点商品编号 比较(lte)
   */
  private String merchantAdjustmentItemIdLte;
  /**
   * 卖家盘点商品编号 比较(contains)
   */
  private String merchantAdjustmentItemIdContains;
  /**
   * 卖家盘点商品编号 比较(notcontains)
   */
  private String merchantAdjustmentItemIdNotcontains;
  /**
   * 卖家盘点商品编号 比较(startswith)
   */
  private String merchantAdjustmentItemIdStartswith;
  /**
   * 卖家盘点商品编号 比较(endswith)
   */
  private String merchantAdjustmentItemIdEndswith;
  /**
   * 卖家盘点商品编号 比较(isnull)
   */
  private Boolean merchantAdjustmentItemIdIsnull;
  /**
   * 卖家盘点商品编号 比较(isnotnull)
   */
  private Boolean merchantAdjustmentItemIdIsnotnull;

  /**
   * 卖家盘点商品编号(精确搜索)
   */
  private List<String> merchantAdjustmentItemIdInList;

  /**
   * MSKU(模糊搜索)
   */
  private String msku;

  /**
   * MSKU 比较(eq)
   */
  private String mskuEq;
  /**
   * MSKU 比较(neq)
   */
  private String mskuNeq;
  /**
   * MSKU 比较(gt)
   */
  private String mskuGt;
  /**
   * MSKU 比较(gte)
   */
  private String mskuGte;
  /**
   * MSKU 比较(lt)
   */
  private String mskuLt;
  /**
   * MSKU 比较(lte)
   */
  private String mskuLte;
  /**
   * MSKU 比较(contains)
   */
  private String mskuContains;
  /**
   * MSKU 比较(notcontains)
   */
  private String mskuNotcontains;
  /**
   * MSKU 比较(startswith)
   */
  private String mskuStartswith;
  /**
   * MSKU 比较(endswith)
   */
  private String mskuEndswith;
  /**
   * MSKU 比较(isnull)
   */
  private Boolean mskuIsnull;
  /**
   * MSKU 比较(isnotnull)
   */
  private Boolean mskuIsnotnull;

  /**
   * MSKU(精确搜索)
   */
  private List<String> mskuInList;

  /**
   * 购买数量
   */
  private Integer quantityPurchased;

  /**
   * 最小购买数量
   */
  private Integer quantityPurchasedMin;

  /**
   * 最大购买数量
   */
  private Integer quantityPurchasedMax;

  /**
   * 购买数量 比较(eq)
   */
  private Integer quantityPurchasedEq;
  /**
   * 购买数量 比较(neq)
   */
  private Integer quantityPurchasedNeq;
  /**
   * 购买数量 比较(gt)
   */
  private Integer quantityPurchasedGt;
  /**
   * 购买数量 比较(gte)
   */
  private Integer quantityPurchasedGte;
  /**
   * 购买数量 比较(lt)
   */
  private Integer quantityPurchasedLt;
  /**
   * 购买数量 比较(lte)
   */
  private Integer quantityPurchasedLte;
  /**
   * 购买数量 比较(contains)
   */
  private Integer quantityPurchasedContains;
  /**
   * 购买数量 比较(notcontains)
   */
  private Integer quantityPurchasedNotcontains;
  /**
   * 购买数量 比较(startswith)
   */
  private Integer quantityPurchasedStartswith;
  /**
   * 购买数量 比较(endswith)
   */
  private Integer quantityPurchasedEndswith;
  /**
   * 购买数量 比较(isnull)
   */
  private Boolean quantityPurchasedIsnull;
  /**
   * 购买数量 比较(isnotnull)
   */
  private Boolean quantityPurchasedIsnotnull;

  /**
   * 店铺
   */
  private Long sid;

  /**
   * 最小店铺
   */
  private Long sidMin;

  /**
   * 最大店铺
   */
  private Long sidMax;

  /**
   * 店铺 比较(eq)
   */
  private Long sidEq;
  /**
   * 店铺 比较(neq)
   */
  private Long sidNeq;
  /**
   * 店铺 比较(gt)
   */
  private Long sidGt;
  /**
   * 店铺 比较(gte)
   */
  private Long sidGte;
  /**
   * 店铺 比较(lt)
   */
  private Long sidLt;
  /**
   * 店铺 比较(lte)
   */
  private Long sidLte;
  /**
   * 店铺 比较(contains)
   */
  private Long sidContains;
  /**
   * 店铺 比较(notcontains)
   */
  private Long sidNotcontains;
  /**
   * 店铺 比较(startswith)
   */
  private Long sidStartswith;
  /**
   * 店铺 比较(endswith)
   */
  private Long sidEndswith;
  /**
   * 店铺 比较(isnull)
   */
  private Boolean sidIsnull;
  /**
   * 店铺 比较(isnotnull)
   */
  private Boolean sidIsnotnull;

  /**
   * 来源(模糊搜索)
   */
  private String eventType;

  /**
   * 来源 比较(eq)
   */
  private String eventTypeEq;
  /**
   * 来源 比较(neq)
   */
  private String eventTypeNeq;
  /**
   * 来源 比较(gt)
   */
  private String eventTypeGt;
  /**
   * 来源 比较(gte)
   */
  private String eventTypeGte;
  /**
   * 来源 比较(lt)
   */
  private String eventTypeLt;
  /**
   * 来源 比较(lte)
   */
  private String eventTypeLte;
  /**
   * 来源 比较(contains)
   */
  private String eventTypeContains;
  /**
   * 来源 比较(notcontains)
   */
  private String eventTypeNotcontains;
  /**
   * 来源 比较(startswith)
   */
  private String eventTypeStartswith;
  /**
   * 来源 比较(endswith)
   */
  private String eventTypeEndswith;
  /**
   * 来源 比较(isnull)
   */
  private Boolean eventTypeIsnull;
  /**
   * 来源 比较(isnotnull)
   */
  private Boolean eventTypeIsnotnull;

  /**
   * 来源(精确搜索)
   */
  private List<String> eventTypeInList;

  /**
   * 报告类型(模糊搜索)
   */
  private String accountType;

  /**
   * 报告类型 比较(eq)
   */
  private String accountTypeEq;
  /**
   * 报告类型 比较(neq)
   */
  private String accountTypeNeq;
  /**
   * 报告类型 比较(gt)
   */
  private String accountTypeGt;
  /**
   * 报告类型 比较(gte)
   */
  private String accountTypeGte;
  /**
   * 报告类型 比较(lt)
   */
  private String accountTypeLt;
  /**
   * 报告类型 比较(lte)
   */
  private String accountTypeLte;
  /**
   * 报告类型 比较(contains)
   */
  private String accountTypeContains;
  /**
   * 报告类型 比较(notcontains)
   */
  private String accountTypeNotcontains;
  /**
   * 报告类型 比较(startswith)
   */
  private String accountTypeStartswith;
  /**
   * 报告类型 比较(endswith)
   */
  private String accountTypeEndswith;
  /**
   * 报告类型 比较(isnull)
   */
  private Boolean accountTypeIsnull;
  /**
   * 报告类型 比较(isnotnull)
   */
  private Boolean accountTypeIsnotnull;

  /**
   * 报告类型(精确搜索)
   */
  private List<String> accountTypeInList;

  /**
   * 财务事件组id(模糊搜索)
   */
  private String financialEventGroupId;

  /**
   * 财务事件组id 比较(eq)
   */
  private String financialEventGroupIdEq;
  /**
   * 财务事件组id 比较(neq)
   */
  private String financialEventGroupIdNeq;
  /**
   * 财务事件组id 比较(gt)
   */
  private String financialEventGroupIdGt;
  /**
   * 财务事件组id 比较(gte)
   */
  private String financialEventGroupIdGte;
  /**
   * 财务事件组id 比较(lt)
   */
  private String financialEventGroupIdLt;
  /**
   * 财务事件组id 比较(lte)
   */
  private String financialEventGroupIdLte;
  /**
   * 财务事件组id 比较(contains)
   */
  private String financialEventGroupIdContains;
  /**
   * 财务事件组id 比较(notcontains)
   */
  private String financialEventGroupIdNotcontains;
  /**
   * 财务事件组id 比较(startswith)
   */
  private String financialEventGroupIdStartswith;
  /**
   * 财务事件组id 比较(endswith)
   */
  private String financialEventGroupIdEndswith;
  /**
   * 财务事件组id 比较(isnull)
   */
  private Boolean financialEventGroupIdIsnull;
  /**
   * 财务事件组id 比较(isnotnull)
   */
  private Boolean financialEventGroupIdIsnotnull;

  /**
   * 财务事件组id(精确搜索)
   */
  private List<String> financialEventGroupIdInList;

  /**
   * 结算状态(模糊搜索)
   */
  private String processingStatus;

  /**
   * 结算状态 比较(eq)
   */
  private String processingStatusEq;
  /**
   * 结算状态 比较(neq)
   */
  private String processingStatusNeq;
  /**
   * 结算状态 比较(gt)
   */
  private String processingStatusGt;
  /**
   * 结算状态 比较(gte)
   */
  private String processingStatusGte;
  /**
   * 结算状态 比较(lt)
   */
  private String processingStatusLt;
  /**
   * 结算状态 比较(lte)
   */
  private String processingStatusLte;
  /**
   * 结算状态 比较(contains)
   */
  private String processingStatusContains;
  /**
   * 结算状态 比较(notcontains)
   */
  private String processingStatusNotcontains;
  /**
   * 结算状态 比较(startswith)
   */
  private String processingStatusStartswith;
  /**
   * 结算状态 比较(endswith)
   */
  private String processingStatusEndswith;
  /**
   * 结算状态 比较(isnull)
   */
  private Boolean processingStatusIsnull;
  /**
   * 结算状态 比较(isnotnull)
   */
  private Boolean processingStatusIsnotnull;

  /**
   * 结算状态(精确搜索)
   */
  private List<String> processingStatusInList;

  /**
   * 转账状态(模糊搜索)
   */
  private String fundTransferStatus;

  /**
   * 转账状态 比较(eq)
   */
  private String fundTransferStatusEq;
  /**
   * 转账状态 比较(neq)
   */
  private String fundTransferStatusNeq;
  /**
   * 转账状态 比较(gt)
   */
  private String fundTransferStatusGt;
  /**
   * 转账状态 比较(gte)
   */
  private String fundTransferStatusGte;
  /**
   * 转账状态 比较(lt)
   */
  private String fundTransferStatusLt;
  /**
   * 转账状态 比较(lte)
   */
  private String fundTransferStatusLte;
  /**
   * 转账状态 比较(contains)
   */
  private String fundTransferStatusContains;
  /**
   * 转账状态 比较(notcontains)
   */
  private String fundTransferStatusNotcontains;
  /**
   * 转账状态 比较(startswith)
   */
  private String fundTransferStatusStartswith;
  /**
   * 转账状态 比较(endswith)
   */
  private String fundTransferStatusEndswith;
  /**
   * 转账状态 比较(isnull)
   */
  private Boolean fundTransferStatusIsnull;
  /**
   * 转账状态 比较(isnotnull)
   */
  private Boolean fundTransferStatusIsnotnull;

  /**
   * 转账状态(精确搜索)
   */
  private List<String> fundTransferStatusInList;

  /**
   * 结算编号(模糊搜索)
   */
  private String financialNo;

  /**
   * 结算编号 比较(eq)
   */
  private String financialNoEq;
  /**
   * 结算编号 比较(neq)
   */
  private String financialNoNeq;
  /**
   * 结算编号 比较(gt)
   */
  private String financialNoGt;
  /**
   * 结算编号 比较(gte)
   */
  private String financialNoGte;
  /**
   * 结算编号 比较(lt)
   */
  private String financialNoLt;
  /**
   * 结算编号 比较(lte)
   */
  private String financialNoLte;
  /**
   * 结算编号 比较(contains)
   */
  private String financialNoContains;
  /**
   * 结算编号 比较(notcontains)
   */
  private String financialNoNotcontains;
  /**
   * 结算编号 比较(startswith)
   */
  private String financialNoStartswith;
  /**
   * 结算编号 比较(endswith)
   */
  private String financialNoEndswith;
  /**
   * 结算编号 比较(isnull)
   */
  private Boolean financialNoIsnull;
  /**
   * 结算编号 比较(isnotnull)
   */
  private Boolean financialNoIsnotnull;

  /**
   * 结算编号(精确搜索)
   */
  private List<String> financialNoInList;

  /**
   * 店铺名(模糊搜索)
   */
  private String storeName;

  /**
   * 店铺名 比较(eq)
   */
  private String storeNameEq;
  /**
   * 店铺名 比较(neq)
   */
  private String storeNameNeq;
  /**
   * 店铺名 比较(gt)
   */
  private String storeNameGt;
  /**
   * 店铺名 比较(gte)
   */
  private String storeNameGte;
  /**
   * 店铺名 比较(lt)
   */
  private String storeNameLt;
  /**
   * 店铺名 比较(lte)
   */
  private String storeNameLte;
  /**
   * 店铺名 比较(contains)
   */
  private String storeNameContains;
  /**
   * 店铺名 比较(notcontains)
   */
  private String storeNameNotcontains;
  /**
   * 店铺名 比较(startswith)
   */
  private String storeNameStartswith;
  /**
   * 店铺名 比较(endswith)
   */
  private String storeNameEndswith;
  /**
   * 店铺名 比较(isnull)
   */
  private Boolean storeNameIsnull;
  /**
   * 店铺名 比较(isnotnull)
   */
  private Boolean storeNameIsnotnull;

  /**
   * 店铺名(精确搜索)
   */
  private List<String> storeNameInList;

  /**
   * 亚马逊店铺id(模糊搜索)
   */
  private String sellerId;

  /**
   * 亚马逊店铺id 比较(eq)
   */
  private String sellerIdEq;
  /**
   * 亚马逊店铺id 比较(neq)
   */
  private String sellerIdNeq;
  /**
   * 亚马逊店铺id 比较(gt)
   */
  private String sellerIdGt;
  /**
   * 亚马逊店铺id 比较(gte)
   */
  private String sellerIdGte;
  /**
   * 亚马逊店铺id 比较(lt)
   */
  private String sellerIdLt;
  /**
   * 亚马逊店铺id 比较(lte)
   */
  private String sellerIdLte;
  /**
   * 亚马逊店铺id 比较(contains)
   */
  private String sellerIdContains;
  /**
   * 亚马逊店铺id 比较(notcontains)
   */
  private String sellerIdNotcontains;
  /**
   * 亚马逊店铺id 比较(startswith)
   */
  private String sellerIdStartswith;
  /**
   * 亚马逊店铺id 比较(endswith)
   */
  private String sellerIdEndswith;
  /**
   * 亚马逊店铺id 比较(isnull)
   */
  private Boolean sellerIdIsnull;
  /**
   * 亚马逊店铺id 比较(isnotnull)
   */
  private Boolean sellerIdIsnotnull;

  /**
   * 亚马逊店铺id(精确搜索)
   */
  private List<String> sellerIdInList;

  /**
   * 国家
   */
  private Long countryCode;

  /**
   * 最小国家
   */
  private Long countryCodeMin;

  /**
   * 最大国家
   */
  private Long countryCodeMax;

  /**
   * 国家 比较(eq)
   */
  private Long countryCodeEq;
  /**
   * 国家 比较(neq)
   */
  private Long countryCodeNeq;
  /**
   * 国家 比较(gt)
   */
  private Long countryCodeGt;
  /**
   * 国家 比较(gte)
   */
  private Long countryCodeGte;
  /**
   * 国家 比较(lt)
   */
  private Long countryCodeLt;
  /**
   * 国家 比较(lte)
   */
  private Long countryCodeLte;
  /**
   * 国家 比较(contains)
   */
  private Long countryCodeContains;
  /**
   * 国家 比较(notcontains)
   */
  private Long countryCodeNotcontains;
  /**
   * 国家 比较(startswith)
   */
  private Long countryCodeStartswith;
  /**
   * 国家 比较(endswith)
   */
  private Long countryCodeEndswith;
  /**
   * 国家 比较(isnull)
   */
  private Boolean countryCodeIsnull;
  /**
   * 国家 比较(isnotnull)
   */
  private Boolean countryCodeIsnotnull;

  /**
   * 表单名称
   */
  private String formName;

  /**
   * 工作流状态
   */
  private Integer wfStatus;
}
